#include <stdio.h>
#include <stdlib.h>

/* 哈夫曼树的定义 */
typedef int TElemSet;
typedef struct BinaryTreeNode *HuffmanTree;
struct BinaryTreeNode {
    TElemSet weight; /* 权重 */
    HuffmanTree left; /* 左孩子指针 */
    HuffmanTree right; /* 右孩子指针 */
};
/* 哈夫曼树的定义结束 */

/* 单根树集合的定义，即树结点的指针数组 */
#define kMaxSize 10000
#define NIL -1
typedef HuffmanTree ElemSet;
typedef struct ListNode *List;
struct ListNode {
    ElemSet data[kMaxSize]; /* 存储数据的数组 */
    int last; /* 线性表中最后一个元素在数组中的位置 */
};
void InitList(List list);
int Length(List list);
/* 单根树集合的定义结束 */

/* 树的集合的定义，即树结点的最小堆 */
typedef HuffmanTree HElemSet;
typedef int Position; /* 数组下标即为元素位置 */
typedef struct BinaryHeapNode *MinHeap;
struct BinaryHeapNode {
    HElemSet *data; /* 数据元素数组 */
    int size; /* 规模 */
    int capacity; /* 容量 */
};
typedef MinHeap TreeSet;

void InitPQueue(MinHeap pq, int capacity);
void SiftUp(MinHeap h, Position i);
void SiftDown(MinHeap h, Position i);
void Insert(MinHeap h, HElemSet x);
HElemSet ExtractMin(MinHeap h);
void MakeHeapDown(MinHeap h);
void MakePQueue(MinHeap h, List list);
/* 树的集合的定义结束 */

HuffmanTree NewNode(TElemSet weight) {
    /* 创建权重为weight的树结点 */
    HuffmanTree tree;

    tree = (HuffmanTree)malloc(sizeof(struct BinaryTreeNode));
    tree->left = NULL;
    tree->right = NULL;
    tree->weight = weight;
    return tree;
}

HuffmanTree CreateHuffmanTree(List w) {
    /* 根据存储原始权重的单根树顺序表w，建立哈夫曼树 */
    HuffmanTree tree;
    TreeSet tree_set;
    int n, i;

    tree_set = (TreeSet)malloc(sizeof(struct BinaryHeapNode));
    n = Length(w); /* n个单根树 */
    InitPQueue(tree_set, n); /* 最小堆的初始化 */
    MakePQueue(tree_set, w); /* 快速建堆 */
    for (i = 1; i < n; i++) { /* 合并二叉树，共n-1次 */
        tree = (HuffmanTree)malloc(sizeof(struct
                                          BinaryTreeNode)); /* 新建树根结点 */
        tree->left = ExtractMin(
                         tree_set); /* 取出根权重最小树作为左子树 */
        tree->right = ExtractMin(
                          tree_set); /* 取出根权重最小树作为右子树 */
        tree->weight = tree->left->weight +
                       tree->right->weight; /* 设置新树的根权重 */
        Insert(tree_set, tree); /* 将新树插入集合tree_set */
    }
    tree = ExtractMin(
               tree_set); /* 取出集合中唯一的二叉树，即哈夫曼树 */
    return tree;
}

int WPL(HuffmanTree tree, int depth) {
    /* 根据Huffman树计算编码总长度 */
    if (tree->left == NULL) /* 是叶子结点 */
        return (depth * tree->weight);
    else /* 否则一定有2个孩子 */
        return (WPL(tree->left, depth + 1) + WPL(tree->right, depth + 1));
}

int main(void) {
    int n, i;
    List nodes;
    TElemSet w;
    HuffmanTree tree;

    scanf("%d", &n);
    nodes = (List)malloc(sizeof(struct ListNode));
    InitList(nodes);
    for (i = 0; i < n; i++) {
        scanf("%d", &w);
        nodes->data[i] = NewNode(w);
        nodes->last++;
    }
    tree = CreateHuffmanTree(nodes);
    printf("%d\n", WPL(tree, 0));

    return 0;
}

void InitList(List list) {
    list->last = -1;
}

int Length(List list) {
    /* 返回list的长度 */
    return (list->last + 1);
}

void InitPQueue(MinHeap pq, int capacity) {
    pq->capacity = capacity;
    pq->size = 0;
    /* 数据从下标1开始存储，需要多声明1个空间 */
    pq->data = (HElemSet *)malloc(sizeof(HElemSet) * (capacity + 1));
}

void SiftUp(MinHeap h, Position i) {
    HElemSet elem;

    elem = h->data[i];
    while (i > 1
            && elem->weight < h->data[i >> 1]->weight) { /* 当前结点小于其父结点 */
        h->data[i] = h->data[i >> 1]; /* 将i的父结点元素下移 */
        i >>= 1; /* i指向原结点的父结点，即向上调整 */
    }
    h->data[i] = elem;
}

void SiftDown(MinHeap h, Position i) {
    Position last, child;
    HElemSet elem;

    last = h->size; /* 这是最后一个元素的位置 */
    elem = h->data[i];
    while (1) {
        child = i << 1; /* child当前是i的左孩子的位置 */
        if (child < last
                && h->data[child + 1]->weight < h->data[child]->weight) { /* 如果i有右孩子并且右孩子更小 */
            child++; /* child更新为i的右孩子的位置 */
        } else if (child > last) { /* 如果i是叶子结点 */
            break; /* 已经调整到底，跳出循环 */
        }
        if (h->data[child]->weight < elem->weight) { /* 若较小的孩子比elem小 */
            h->data[i] = h->data[child]; /* 将较小的孩子结点上移 */
            i = child; /* i指向原结点的孩子结点，即向下调整 */
        } else { /* 若所有孩子都不比elem小 */
            break; /* 则找到了elem的最终位置，跳出循环 */
        }
    }
    h->data[i] = elem;
}

void Insert(MinHeap h, HElemSet x) {
    Position last;

    if (h->size == h->capacity) { /* 堆已满 */
        printf("错误：堆已满，无法插入。\n");
    } else {
        h->size++;
        last = h->size;
        h->data[last] = x; /* 暂时将x放入最后一个元素的位置 */
        SiftUp(h, last);
    }
}

HElemSet ExtractMin(MinHeap h) {
    HElemSet min_key;
    Position last;

    min_key = h->data[1]; /* 这是将要返回的最小元 */
    last = h->size; /* 这是删除前最后一个元素的位置 */
    h->size--;
    h->data[1] =
        h->data[last]; /* 暂时将删除前最后一个元素放入根的位置 */
    SiftDown(h, 1); /* 从根结点下调 */
    return min_key;
}

void MakeHeapDown(MinHeap h) {
    Position last;
    int i;

    last = h->size; /* 这是最后一个元素的位置 */
    for (i = last >> 1; i > 0; i--) {
        SiftDown(h, i); /* 自底向上调整 */
    }
}

void MakePQueue(MinHeap h, List list) {
    /* 以 list 中所有元素创建一个优先级队列 pq */
    int n, i;

    n = list->last + 1; /* 获得表长 */
    for (i = 0; i < n; i++) {
        h->data[i + 1] = list->data[i]; /* 复制list到pq中 */
    }
    h->size = n;
    MakeHeapDown(h); /* 快速建堆 */
}